(FILECREATED "20-NOV-73 20:28:02" PUP3)
(DEFINEQ
(A:BEING:ORDER
[LAMBDA (B1 B2)
(LESSP (FAST:BEING:COMPLEX B1)
(FAST:BEING:COMPLEX B2])
(A:BEING:WHEN
[LAMBDA (BB)
(SETQ SUM 0)
[FOR W IN (GETP BB WHEN) DO (COND
((ATTEMPT (EVAL (CAR W))
THEN T)
(SETQ SUM
(PLUS SUM (EVAL (CADR W]
SUM])
(AD
[LAMBDA (L)
(SETQ PUP3FNS (SORT (APPEND PUP3FNS L)))
(SETQ PUP3FNS (INTERSECTION PUP3FNS PUP3FNS))
(FOR X IN SET:OF:BEINGS DO (PUT X SPEC:WHY (TUPLE NO SPECIAL REASON)
))
(MAKEFILE (QUOTE PUP3])
(ADD:BEING
[LAMBDA (B)
(SET B B)
(PUT B BEING T)
[FOR X IN SET:OF:BEING:PARTS DO (PROGN (PRIN1 X)
(PRIN1 " ")
(PUT B X (READ]
(PRIN1
"*** FINISHED ***
SHOULD I MAKE A NEW FILE OF PUP? (T OR NIL)..... ")
(SETQ SET:OF:BEINGS (CONS B SET:OF:BEINGS))
(SEMI:COMPILE B)
(COND
((RATOM)
(AD (LIST B])
(BLIND:BREAK:UP
(QLAMBDA (←←X1
←←X2
←←X3
←←X4)
[MATCHQ ←BREAK:RESULT
(EVAL (CONS (QUOTE APPEND)
(MAPCAR (TUPLE $X1 $X2 $X3 $X4)
LOOKUP]
(ASSERT (EXECUTABLE $BREAK:RESULT))
$BREAK:RESULT BACKTRACK))
(CHANGEB
[LAMBDA (B:NAME B:PART)
(SETQ TEMP (GETP B:NAME B:PART))
(EDITV TEMP)
(PUT B:NAME B:PART TEMP)
(COND
((MEMBER B:PART COMPILABLE:BEING:PARTS)
(SEMI:COMPILE B:NAME)))
T])
(COLON:BACK
[LAMBDA (LL)
(SETQ MM (CAR LL))
[SETQ LL (MAPCAR (CDR LL)
(FUNCTION (LAMBDA (E)
(CONCAT ":" E]
(SETQ LL (CONS MM LL))
(PACK LL])
(COLON:BREAK
[LAMBDA (E)
(PROG (UP RP)
(SETQ UP (UNPACK E))
(SETQ BUFF NIL)
LL [COND
((NULL UP)
(SETQ RP (CONS (PACK BUFF)
RP))
(RETURN (REVERSE RP]
[COND
((MEMBER (CAR UP)
BREAKUP:LIST)
(SETQ RP (CONS (PACK BUFF)
RP))
(SETQ BUFF NIL))
(T (SETQ BUFF (NCONC1 BUFF (CAR UP]
(SETQ UP (CDR UP))
(GO LL])
(DIMENSION1
[LAMBDA (B)
(EVAL (CAR (GETP B COMPLEXITY:VECTOR])
(DIMENSION2
[LAMBDA (B)
(EVAL (CADR (GETP B COMPLEXITY:VECTOR])
(DIMENSION3
[LAMBDA (B)
(EVAL (CADDR (GETP B COMPLEXITY:VECTOR])
(DISK:DUMP
[LAMBDA (FILE STUFF)
(SETQ FILEVARS (MKATOM (CONCAT (MKSTRING FILE)
"VARS")))
(SET FILEVARS (QUOTE (EVERYTHING)))
(SETQ EVERYTHING STUFF)
(MAKEFILE FILE])
(DOT:PROD
[LAMBDA (L1 L2)
(COND
[L1 (PLUS (TIMES (CAR L1)
(CAR L2))
(DOT:PROD (CDR L1)
(CDR L2]
(T 0])
(DUMP:BEING
[LAMBDA (B)
(PRIN1 "************************* ")
(PRINT B)
[FOR X IN SET:OF:BEING:PARTS DO (COND
((SETQ X2 (GETP B X))
(PRINT X)
(PP X2)
(TERPRI]
(QUOTE FINISHED])
(FAST:BEING:COMPLEX
[LAMBDA (B)
(DOT:PROD (QUOTE (.1 .6 .3))
(MAPCAR (GETP B COMPLEXITY:VECTOR)
EVAL])
(FIRST:FEW
[LAMBDA (L)
(SETQ N (PLUS 1 (IQUOTIENT (LENGTH L)
2)))
(REVERSE (NTH (REVERSE L)
N])
(FOREACH
[LAMBDA (X IN SET DO ACTION)
(PROG (RESULT)
START:HERE
(COND
((NULL SET)
(RETURN RESULT)))
(SET X (CAR SET))
(SETQ SET (CDR SET))
(SETQ RESULT (EVAL ACTION))
(GO START:HERE])
(INITIALS
[LAMBDA (L)
(MAPCAR L (FUNCTION (LAMBDA (E)
(CAR (UNPACK E])
(LOOKUP
[LAMBDA (ANY)
(COND
((NULL ANY)
NIL)
(T
(PROG (SUCC)
[FOR X IN SET:OF:BEINGS
DO (FOR Y IN (GETP X IDEN)
DO (PROGN (MATCHQ ←YY
(CAR Y))
(ATTEMPT (MATCHQ $YY ANY)
THEN (RETURN
(SETQ SUCC
(MAPCAR (CADR Y)
EVAL)))
ELSE NIL]
(COND
(SUCC (RETURN (CONS (QUOTE TUPLE)
SUCC)))
(T (IS (TRANSLATION OF (@ ANY)
IS ←T1))
(IS (EXECUTABLE $T1))
(RETURN $T1])
(MAIN:WORDS
[LAMBDA (L)
(SETDIFFERENCE L MINOR:WORDS])
(PERMIT:USER:INTERRUPT
[LAMBDA NIL
(COND
(EXPERTISE (PRIN1 "INTERRUPT? "))
(T (PRIN1
"
DO YOU WISH TO INTERRUPT ME NOW, TO ASK ME ABOUT WHAT I'M DOING? ")))
(SELECTQ (RATOM)
(Y (PROCESS:USER:INTERRUPT))
(N NIL)
(PROGN (PRIN1 "
NO, NO. TYPE Y OR N ......... ")
(PERMIT:USER:INTERRUPT])
(POP:DEMONS
[LAMBDA NIL
(MATCHQ (←CURRENT:DEMONS
←←DEMON:STACK)
$DEMON:STACK])
(PROCESS:USER:INTERRUPT
[LAMBDA NIL
(QPROG (RESPONSE ←BC
←BC1
←BC2)
(COND
((NOT EXPERTISE)
[PRINT (APPEND (QUOTE (BEING IS))
(LIST (CAR BEING:STACK]
(PRIN1 " TYPE ? OR ")))
(MATCHQ (←BC
←←BC2)
BEING:STACK)
(MATCHQ ←BC1
(TUPLE))
L
(PRIN1 " REQUEST: ")
(ATTEMPT [SELECTQ (SETQ RESPONSE (READ))
[? (PRIN1
" YOUR OPTIONS ARE AS FOLLOWS:
QUIT END THE INTERRUPT
BEING PRINT NAME OF CURRENT BEING
DEMONS PRINT SET OF DEMONS CURRENTLY ACTIVE
CONTROL:HISTORY PRINT LIST OF BEINGS IN CONTROL, THE PATH FROM THE
CURRENT BEING BACK TO THE BEGINNING OF THE PROGRAM
OLDER CONSIDER THE BEING WHICH CALLED THE CURRENT ONE
YOUNGER CONSIDER THE BEING WHICH THE CURRENT ONE CALLED
OLDEST CONSIDER THE FIRST BEING IN CONTROL
YOUNGEST CONSIDER THE LAST BEING IN CONTROL
")
(PRIN1
"SPEC:WHY PRINT OUT THE SPECIFIC REASON(S) THAT THIS BEING WAS
CALLED. THIS DIFFERS FROM 'WHY' IN SENSE THAT SPEC:WHY IS
THE REASON GIVEN BY THE CALLER, WHERAS WHY IS THE REASON
STORED WITH THE CURRENT BEING PERMANENTLY.
")
(MAPC SET:OF:BEING:PARTS
(FUNCTION (LAMBDA (Y)
(PRIN1 Y)
(PRIN1 " PRINT OUT ")
(PRIN1 Y)
(PRIN1
" WITH RESPECT TO CURRENT BEING
"]
(QUIT (COND
((NOT EXPERTISE)
(PRIN1 "
END OF INTERRUPT
")))
(RETURN))
(BEING (PRINT $BC))
(CONTROL:HISTORY (PRIN1 $BC1)
(PRIN1 " *** ")
(PRIN1 $BC)
(PRIN1 " *** ")
(PRIN1 $BC2)
(TERPRI))
(DEMONS (PRIN1 $CURRENT:DEMONS)
(PRIN1 "
THE DEMON STACK IS ")
(PRINT $DEMON:STACK))
(OLDER (MATCHQ ←BC1
(TUPLE $$BC1 $BC))
(MATCHQ (←BC
←←BC2)
$BC2)
(PRINT $BC))
(YOUNGER (MATCHQ ←BC2
(TUPLE $BC $$BC2))
(MATCHQ (←←BC1
←BC)
$BC1)
(PRINT $BC))
(OLDEST (MATCHQ (←←BC1
←BC)
BEING:STACK)
(MATCHQ ←BC2
(TUPLE))
(PRINT $BC))
(YOUNGEST (MATCHQ (←BC
←←BC2)
BEING:STACK)
(MATCHQ ←BC1
(TUPLE))
(PRINT $BC))
(COND
((MEMBER RESPONSE NON:EVAL:BEING:PARTS)
(PRINT (GETP $BC RESPONSE)))
[(MEMBER RESPONSE EVAL:BEING:PARTS)
(PRINT (EVAL (GETP $BC RESPONSE]
((NLSETQ (PRINT (EVAL RESPONSE)))
T)
(T (FAIL]
THEN T
ELSE (PRIN1
"
*** ERROR *** IMPOSSIBLE. TYPE ? FOR HELP.
"))
(GO L])
(PULLOUT
[LAMBDA (E L)
(COND
((ATOM L)
L)
((EQUAL E (CAR L))
(CDR L))
(T (CONS (CAR L)
(PULLOUT E (CDR L])
(PUSH:DEMONS
[LAMBDA (NEW:DEMONS)
(MATCHQ ←NEW:DEMO
(SETDIFFERENCE NEW:DEMONS $CURRENT:DEMONS))
(MATCHQ ←DEMON:STACK
(TUPLE $CURRENT:DEMONS $$DEMON:STACK))
(MATCHQ ←CURRENT:DEMONS
(TUPLE $$NEW:DEMO $$CURRENT:DEMONS])
(SEMI:COMPILE
[LAMBDA (B)
(EVAL (LIST (QUOTE DEFINEQ)
(LIST B (APPEND (QUOTE [LAMBDA])
(LIST (APPEND (GETP B EXPLICIT:ARGS)
(GETP B IMPLICIT:ARGS)))
[LIST (LIST (QUOTE /SETQ)
(QUOTE BEING:STACK)
(LIST (QUOTE CONS)
B
(QUOTE BEING:STACK]
(LIST (GETP B EXPLICIT:ARGS:CHECK))
[MAPCAR (GETP B PRE:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY
(LIST (QUOTE QUOTE)
X]
(LIST (LIST (QUOTE PUSH:DEMONS)
(GETP B DEMONS)))
[MAPCAR (GETP B CO:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST TRY:TO:SATISFY
(LIST (QUOTE QUOTE)
X]
(GETP B COMMENTS)
(LIST (LIST (QUOTE PUT)
B SPEC:WHY (QUOTE BECAUSE)))
(QUOTE ((ASSERT (APPLYING DEMONS)
APPLY
$USER:INTERRUPT:DEMONS)))
(LIST (LIST (QUOTE SETQ)
(QUOTE FN:VALUE)
(GETP B META:CODE)))
[MAPCAR (GETP B CO:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY
(LIST (QUOTE QUOTE)
X]
(QUOTE ((POP:DEMONS)))
[MAPCAR (GETP B POST:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY
(LIST (QUOTE QUOTE)
X]
[QUOTE ((/SETQ BEING:STACK
(CDR BEING:STACK]
(QUOTE (FN:VALUE])
(SETDIFFERENCE
[LAMBDA (S1 S2)
(COND
((NULL S1)
NIL)
(T (APPEND [COND
((MEMBER (CAR S1)
S2)
NIL)
(T (LIST (CAR S1]
(SETDIFFERENCE (CDR S1)
S2])
(SETINTERSECTION
[LAMBDA (S1 S2)
(INTERSECTION S1 S2])
(SETUNION
[LAMBDA (S1 S2)
(SETQ S1 (APPEND S1 S2))
(INTERSECTION S1 S1])
(SINGLETON
[LAMBDA (S)
(NULL (CDR S])
(SIZE
[LAMBDA (STRUC)
(QUOTIENT (COUNT STRUC)
2])
(SPECIFICITY:CHECK:DEMON
[LAMBDA (ANYTHING)
(ATTEMPT (BIS (PUP WANTS ←←DESIRED)
THEN (ATTEMPT (IS (SPECIFIC $$DESIRED))
THEN (FAIL)
ELSE (PROGN (MAKE:SPECIFIC $$DESIRED)
(FAIL])
(START
[LAMBDA (EXPERTISE)
(PROG NIL
(SETQ Y (QUOTE Y))
(SETQ N (QUOTE N))
(SETQ BEING:STACK NIL)
(SETQ BECAUSE NIL)
(SETQ KNOWN:NAMES T)
(MATCHQ ←DEMON:STACK
(TUPLE))
(MATCHQ ←CURRENT:DEMONS
(TUPLE))
(COND
(EXPERTISE (PRIN1 "USER INTERRUPT LEVEL... "))
(T (PRIN1
"HELLO THERE. I AM READY TO START .
HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
4 DURING EACH PHASE OF WRITING A PROGRAM
6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
OK, NOW TYPE A DIGIT... ")))
L [MATCHQ ←PERMANENT:USER:INTERRUPT:DEMONS
(SELECTQ (RATOM)
(0 (CLASS))
(2 (CLASS USER:INTERRUPT:AT:DEBUG
USER:INTERRUPT:AT:END))
(4 (CLASS USER:INTERRUPT:AT:PHASES))
(6 (CLASS USER:INTERRUPT:AT:PHASES
USER:INTERRUPT:AT:CODING))
(8 (CLASS USER:INTERRUPT:AT:PHASES
USER:INTERRUPT:AT:CODING
USER:INTERRUPT:AT:ADAPTING))
(10 (CLASS PERMIT:USER:INTERRUPT))
(AND (PRIN1
"
*** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
TRY AGAIN:
")
(GO L]
(MATCHQ ←USER:INTERRUPT:DEMONS
$PERMANENT:USER:INTERRUPT:DEMONS)
(SETQ USER:INTERRUPT:COPY:OF:PHASES PROGRAM:WRITING:PHASES)
(SERVE])
(SUBSTITUTE
[LAMBDA (NEW FOR OLD IN LIST:STRUCTURE)
(SET LIST:STRUCTURE (SUBST NEW OLD (EVAL LIST:STRUCTURE])
(TRY:TO:SATISFY
[LAMBDA (SUBGOAL)
(ATTEMPT (SATISFY SUBGOAL)
THEN T
ELSE (SETQ FINAL:CO:REQ (CONS SUBGOAL FINAL:CO:REQ])
(USER:INTERRUPT:AT:ADAPTING
[LAMBDA (S:EXP)
(COND
((EQUAL B ADAPT:PRECONCEIVED:FUNCTION)
(PERMIT:USER:INTERRUPT)
(MATCHQ (CLASS USER:INTERRUPT:AT:ADAPTING
←←USER:INTERRUPT:DEMONS)
$USER:INTERRUPT:DEMONS])
(USER:INTERRUPT:AT:CODING
[LAMBDA (S:EXP)
(COND
((EQUAL B ENCODE)
(PERMIT:USER:INTERRUPT)
(MATCHQ (CLASS USER:INTERRUPT:AT:CODING ←←USER:INTERRUPT:DEMONS)
$USER:INTERRUPT:DEMONS])
(USER:INTERRUPT:AT:DEBUG
[LAMBDA (S:EXP)
(COND
((EQUAL B CLARIFY:IMPROBABLE:SITUATION)
(PERMIT:USER:INTERRUPT)
(MATCHQ (CLASS USER:INTERRUPT:AT:DEBUG ←←USER:INTERRUPT:DEMONS)
$USER:INTERRUPT:DEMONS])
(USER:INTERRUPT:AT:END
[LAMBDA (S:EXP)
(COND
((EQUAL B OPTIMIZE)
(PERMIT:USER:INTERRUPT)
(MATCHQ (CLASS USER:INTERRUPT:AT:END ←←USER:INTERRUPT:DEMONS)
$USER:INTERRUPT:DEMONS])
(USER:INTERRUPT:AT:PHASES
[LAMBDA (S:EXP)
(COND
((MEMBER B USER:INTERRUPT:COPY:OF:PHASES)
(PERMIT:USER:INTERRUPT)
(SETQ USER:INTERRUPT:COPY:OF:PHASES (PULLOUT B
USER:INTERRUPT:COPY:OF:PHASES])
(WHEN:VALUE
[LAMBDA (B:CALL)
(SETQ EXP:A (GETP (CAR B:CALL)
EXPLICIT:ARGS))
(FOR NEW:ARG IN EXP:A AS OLD:ARG IN (CDR B:CALL)
DO (SET NEW:ARG OLD:ARG))
(ATTEMPT (EVAL (GETP (CAR B:CALL)
EXPLICIT:ARGS:CHECK))
THEN (A:BEING:WHEN (CAR B:CALL))
ELSE -1000])
)
(LISPXPRINT (QUOTE PUP3FNS)
T)
(RPAQQ PUP3FNS
(A:BEING:ORDER A:BEING:WHEN AD ADD:BEING BLIND:BREAK:UP
CHANGEB COLON:BACK COLON:BREAK DIMENSION1
DIMENSION2 DIMENSION3 DISK:DUMP DOT:PROD
DUMP:BEING FAST:BEING:COMPLEX FIRST:FEW FOREACH
INITIALS LOOKUP MAIN:WORDS
PERMIT:USER:INTERRUPT POP:DEMONS
PROCESS:USER:INTERRUPT PULLOUT PUSH:DEMONS
SEMI:COMPILE SETDIFFERENCE SETINTERSECTION
SETUNION SINGLETON SIZE SPECIFICITY:CHECK:DEMON
START SUBSTITUTE TRY:TO:SATISFY
USER:INTERRUPT:AT:ADAPTING
USER:INTERRUPT:AT:CODING
USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END
USER:INTERRUPT:AT:PHASES WHEN:VALUE))
(LISPXPRINT (QUOTE PUP3VARS)
T)
[RPAQQ PUP3VARS
(SET:OF:BEINGS BEING MINOR:WORDS BREAKUP:LIST
COMPILABLE:BEING:PARTS INFERIOR SUPERIOR
NON:EXECUTABLE NON:EVAL:BEING:PARTS
EVAL:BEING:PARTS SET:OF:BEING:PARTS
PROGRAM:WRITING:PHASES EVAL
(VARS * (APPEND PUP3FNS SET:OF:BEINGS
SET:OF:BEING:PARTS))
(COMS * (LIST (APPEND (QUOTE (PROP ALL))
SET:OF:BEINGS)))
(P (MAPC SET:OF:BEINGS SEMI:COMPILE]
(RPAQQ SET:OF:BEINGS
(ANALYZE:IMPLICATIONS BETTER CHOOSE:FROM CONCEPT:FORMATION
EXTRACT:RELEVANT:SUBSET GET:NAME
GET:NEW:INFORMATION MESSAGE
OBTAIN:USABLE:INFORMATION
PROPOSE:PLAUSIBLE:NAMES SATISFY SERVE
TRANSLATE TRY:BEING WRITE:PROGRAM))
(RPAQQ BEING BEING)
(RPAQQ MINOR:WORDS
(A AT DO DOES FOR IN PROGRAM THE TO WHICH WHILE WRITE))
(RPAQQ BREAKUP:LIST (:))
(RPAQQ COMPILABLE:BEING:PARTS
(META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES
POST:REQUISITES EXPLICIT:ARGS EXPLICIT:ARGS:CHECK
IMPLICIT:ARGS))
(RPAQQ INFERIOR INFERIOR)
(RPAQQ SUPERIOR SUPERIOR)
(RPAQQ NON:EXECUTABLE NON:EXECUTABLE)
(RPAQQ NON:EVAL:BEING:PARTS
(IDEN IMPLICIT:ARGS EXPLICIT:ARGS WHEN META:CODE COMMENTS
PRE:REQUISITES CO:REQUISITES POST:REQUISITES
EXPLICIT:ARGS:CHECK DEMONS MAIN:EFFECTS MINOR:EFFECTS
COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS
ALTERNATIVES))
(RPAQQ EVAL:BEING:PARTS (WHAT HOW WHY AFFECTS SPEC:WHY))
(RPAQQ SET:OF:BEING:PARTS
(IDEN IMPLICIT:ARGS EXPLICIT:ARGS EXPLICIT:ARGS:CHECK WHAT HOW
WHY SPEC:WHY MAIN:EFFECTS MINOR:EFFECTS WHEN META:CODE
COMMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES
DEMONS AFFECTS COMPLEXITY:VECTOR GENERALIZATIONS
SPECIALIZATIONS ALTERNATIVES))
(RPAQQ PROGRAM:WRITING:PHASES (OBTAIN:USABLE:INFORMATION
USE:INFORMATION
FILL:IN:UNDEFINED:SECTION
ADAPT:PRECONCIVED:FUNCTION
CLARIFY:IMPROBABLE:SITUATION
FIX:INCORRECT:PIECE
OPTIMIZE))
(RPAQQ EVAL EVAL)
(RPAQQ A:BEING:ORDER A:BEING:ORDER)
(RPAQQ A:BEING:WHEN A:BEING:WHEN)
(RPAQQ AD AD)
(RPAQQ ADD:BEING ADD:BEING)
(RPAQQ BLIND:BREAK:UP NOBIND)
(RPAQQ CHANGEB CHANGEB)
(RPAQQ COLON:BACK NOBIND)
(RPAQQ COLON:BREAK NOBIND)
(RPAQQ DIMENSION1 NOBIND)
(RPAQQ DIMENSION2 NOBIND)
(RPAQQ DIMENSION3 NOBIND)
(RPAQQ DISK:DUMP DISK:DUMP)
(RPAQQ DOT:PROD DOT:PROD)
(RPAQQ DUMP:BEING DUMP:BEING)
(RPAQQ FAST:BEING:COMPLEX FAST:BEING:COMPLEX)
(RPAQQ FIRST:FEW NOBIND)
(RPAQQ FOREACH FOREACH)
(RPAQQ INITIALS NOBIND)
(RPAQQ LOOKUP LOOKUP)
(RPAQQ MAIN:WORDS NOBIND)
(RPAQQ PERMIT:USER:INTERRUPT PERMIT:USER:INTERRUPT)
(RPAQQ POP:DEMONS POP:DEMONS)
(RPAQQ PROCESS:USER:INTERRUPT PROCESS:USER:INTERRUPT)
(RPAQQ PULLOUT PULLOUT)
(RPAQQ PUSH:DEMONS PUSH:DEMONS)
(RPAQQ SEMI:COMPILE SEMI:COMPILE)
(RPAQQ SETDIFFERENCE SETDIFFERENCE)
(RPAQQ SETINTERSECTION SETINTERSECTION)
(RPAQQ SETUNION SETUNION)
(RPAQQ SINGLETON SINGLETON)
(RPAQQ SIZE SIZE)
(RPAQQ SPECIFICITY:CHECK:DEMON SPECIFICITY:CHECK:DEMON)
(RPAQQ START START)
(RPAQQ SUBSTITUTE SUBSTITUTE)
(RPAQQ TRY:TO:SATISFY TRY:TO:SATISFY)
(RPAQQ USER:INTERRUPT:AT:ADAPTING USER:INTERRUPT:AT:ADAPTING)
(RPAQQ USER:INTERRUPT:AT:CODING USER:INTERRUPT:AT:CODING)
(RPAQQ USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:DEBUG)
(RPAQQ USER:INTERRUPT:AT:END USER:INTERRUPT:AT:END)
(RPAQQ USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:PHASES)
(RPAQQ WHEN:VALUE WHEN:VALUE)
(RPAQQ ANALYZE:IMPLICATIONS ANALYZE:IMPLICATIONS)
(RPAQQ BETTER BETTER)
(RPAQQ CHOOSE:FROM CHOOSE:FROM)
(RPAQQ CONCEPT:FORMATION CONCEPT:FORMATION)
(RPAQQ EXTRACT:RELEVANT:SUBSET EXTRACT:RELEVANT:SUBSET)
(RPAQQ GET:NAME GET:NAME)
(RPAQQ GET:NEW:INFORMATION GET:NEW:INFORMATION)
(RPAQQ MESSAGE MESSAGE)
(RPAQQ OBTAIN:USABLE:INFORMATION OBTAIN:USABLE:INFORMATION)
(RPAQQ PROPOSE:PLAUSIBLE:NAMES PROPOSE:PLAUSIBLE:NAMES)
(RPAQQ SATISFY SATISFY)
(RPAQQ SERVE SERVE)
(RPAQQ TRANSLATE TRANSLATE)
(RPAQQ TRY:BEING TRY:BEING)
(RPAQQ WRITE:PROGRAM WRITE:PROGRAM)
(RPAQQ IDEN IDEN)
(RPAQQ IMPLICIT:ARGS IMPLICIT:ARGS)
(RPAQQ EXPLICIT:ARGS EXPLICIT:ARGS)
(RPAQQ EXPLICIT:ARGS:CHECK EXPLICIT:ARGS:CHECK)
(RPAQQ WHAT WHAT)
(RPAQQ HOW HOW)
(RPAQQ WHY WHY)
(RPAQQ SPEC:WHY SPEC:WHY)
(RPAQQ MAIN:EFFECTS MAIN:EFFECTS)
(RPAQQ MINOR:EFFECTS MINOR:EFFECTS)
(RPAQQ WHEN WHEN)
(RPAQQ META:CODE META:CODE)
(RPAQQ COMMENTS COMMENTS)
(RPAQQ PRE:REQUISITES PRE:REQUISITES)
(RPAQQ CO:REQUISITES CO:REQUISITES)
(RPAQQ POST:REQUISITES POST:REQUISITES)
(RPAQQ DEMONS DEMONS)
(RPAQQ AFFECTS AFFECTS)
(RPAQQ COMPLEXITY:VECTOR COMPLEXITY:VECTOR)
(RPAQQ GENERALIZATIONS GENERALIZATIONS)
(RPAQQ SPECIALIZATIONS SPECIALIZATIONS)
(RPAQQ ALTERNATIVES ALTERNATIVES)
(PUTPROPS ANALYZE:IMPLICATIONS IDEN [((ANALYZE:IMPLICATIONS ←NEW:INFO)
(LIST ANALYZE:IMPLICATIONS
(TRANSLATE $NEW:INFO]
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE ANALYZE THE IMPLICATIONS
OF SOME OF THE NEW
INFORMATION (@ NEW:INFO))
HOW (TUPLE BY LOCALIZING THE EFFECTS
OF THE NEW INFO AND
STUDYING THEM)
WHY (TUPLE TO IMPROVE THE
UNDERSTANDING THAT PUP HAS
OF THE NEW INFORMATION
(@ NEW:INFO))
SPEC:WHY (NO SPECIAL REASON)
WHEN (((IS (USABLE INFORMATION ←←ANY))
-60
(TUPLE BECAUSE WE SHOULD USE
$ANY BEFORE WORRYING
ABOUT (@ NEW:INFO)))
(T (DIFFERENCE 50 (SIZE NEW:INFO)
)
(TUPLE BECAUSE THE SIZE OF
THE NEW INFORMATION
(@ NEW:INFO)
AFFECTS HOW EASILY AND
FRUITFULLY AN ANALYSIS
OF IT WILL BE)))
META:CODE (PROGN (LOCATE:AFFECTED:AREA
NEW:INFO)
(PREDICT:AFFECT
NEW:INFO)
(EVALUATE:AFFECT
NEW:INFO))
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK (IS
(RELEVANT
INFORMATION
(@ NEW:INFO)))
DEMONS NIL
MAIN:EFFECTS (((AWARE PUP
(IMPLICATIONS
←NEW:INFO))
(ANALYZE:IMPLICATIONS
$NEW:INFO)))
MINOR:EFFECTS NIL
AFFECTS (TUPLE (LOCATE AFFECTED:AREA
CALLED)
(PREDICT:AFFECT CALLED)
(EVALUATE:AFFECT CALLED)
)
COMPLEXITY:VECTOR (.4 .7 .7 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS BETTER IDEN [((BETTER ←B1 ←B2)
(LIST BETTER (TRANSLATE $B1)
(TRANSLATE $B2]
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (B1 B2)
WHAT (TUPLE DECIDE WHICH OF (@ B1)
(@ B2)
IS MORE A PROPOS TO TRY)
HOW (TUPLE COMPARE THE WHEN PARTS OF
(@ (CAR B1))
AND
(@ (CAR B2))
AND, IF NECESSARY, COMPARE THEIR
COMPLEXITY VECTORS)
WHY (TUPLE PUP CAN ONLY TRY AT MOST ONE OF
(@ (CAR B1))
AND
(@ (CAR B2))
AT A TIME)
SPEC:WHY (TUPLE WE MUST SELECT THE BEST BEING FROM
(TRANSLATE GET:NEW:INFORMATION
ANALYZE:IMPLICATIONS
EXTRACT:RELEVANT:SUBSET)
THE WHEN PART OF THE
GET:NEW:INFORMATION IS INFERIOR TO
THE WHEN PART OF TRANSLATE THE WHEN
PART OF THE ANALYZE:IMPLICATIONS IS
INFERIOR TO THE WHEN PART OF
TRANSLATE)
WHEN NIL
META:CODE (ATTEMPT
(PROGN
(SETQ B1NEW B1)
(SETQ B2NEW B2)
(SETQ B1NEW
(CONS (CAR B1NEW)
(MAPCAR (CDR B1NEW)
EVAL)))
(SETQ B2NEW
(CONS (CAR B2NEW)
(MAPCAR (CDR B2NEW)
EVAL)))
(SETQ WHEN:DIFF (DIFFERENCE
(WHEN:VALUE B1NEW)
(WHEN:VALUE B2NEW)))
[COND
[(EQP WHEN:DIFF 0)
(SETQ RESULT1 (A:BEING:ORDER
(CAR B1NEW)
(CAR B2NEW)))
(/SETQ
BECAUSE
(APPEND
BECAUSE
(TUPLE
THE WHEN PARTS OF
(@ (CAR B1NEW))
AND
(@ (CAR B2NEW))
ARE EQUAL AND THE FORMER IS
[@ (COND (RESULT1
(QUOTE LESS))
(T (QUOTE MORE]
COMPLEX THAN THE LATTER BEING]
(T
(SETQ RESULT1 (NOT (MINUSP
WHEN:DIFF)))
(/SETQ
BECAUSE
(APPEND
BECAUSE
(TUPLE THE WHEN PART OF THE
(@ (CAR B1NEW))
IS
(@ (COND (RESULT1
SUPERIOR)
(T INFERIOR)))
TO THE WHEN PART OF
(@ (CAR B2NEW]
RESULT1))
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK (COND
((AND
(EQUAL T
(GETP (CAR B1)
BEING))
(EQUAL T
(GETP (CAR B2)
BEING)))
T)
(T (FAIL)))
DEMONS NIL
MAIN:EFFECTS NIL
MINOR:EFFECTS NIL
AFFECTS NIL
COMPLEXITY:VECTOR NIL
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS CHOOSE:FROM IDEN [((CHOOSE:FROM ←S)
(LIST CHOOSE:FROM (TRANSLATE $S]
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (S)
WHAT (TUPLE CHOOSE THE BEST BEING FROM THE SET
(@ S)
OF BEINGS)
HOW (TUPLE COMPARE FEATURES OF THE ELEMENTS OF
THE SET (@ S)
OF BEINGS)
WHY (TUPLE BECAUSE THE FLOW OF CONTROL OF A
PROGRAM MUST BE DETERMINATE)
SPEC:WHY (TUPLE WE CAN ONLY TRY TO OBTAIN
USABLE INFORMATION IN ONE WAY
AT A TIME)
WHEN NIL
META:CODE [PROG
(BEST)
(/SETQ S (CDR S))
(SETQ BEST (CAR S))
[/SETQ
BECAUSE
(TUPLE
TUPLE WE MUST SELECT THE BEST
BEING FROM
(@ (MAPCAR S (QUOTE CAR]
[COND
[(SINGLETON S)
(/SETQ
BECAUSE
(APPEND
BECAUSE
(TUPLE AND, TRIVIALLY,
(@ (CAR S))
IS OUR ONLY CHOICE]
(T (FOR S1 IN (CDR S)
DO
(COND ((BETTER S1 BEST)
(SETQ BEST S1]
(/SETQ
BECAUSE
(TUPLE
TUPLE NOW THAT WE HAVE SELECTED
(@ (CAR BEST))
AS THE BEST BEING OUT OF THE
SET (@ (MAPCAR S (QUOTE CAR)))
WE MUST CARRY OUT (@ BEST)))
(ATTEMPT
(EVAL BEST)
THEN T ELSE
(CHOOSE:FROM
(EVAL
(CONS (QUOTE CLASS)
(@ (PULLOUT BEST S]
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK (PROGN
[FOR
S1 IN (CDR S)
DO
(COND
(NIL 6)
((EQUAL
T
(GETP
(CAR S1)
BEING))
T)
(T (FAIL]
(MATCHQ (CLASS ←←S3)
(@ S)))
DEMONS NIL
MAIN:EFFECTS [((BETTER:THAN ←S1 ←S2)
(CHOOSE:FROM (CLASS $S1 $$S2]
MINOR:EFFECTS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.2 .4 .6 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
NIL T)
(PUTPROPS CONCEPT:FORMATION BEING T
IDEN (((CONCEPT FORMATION)
(CONCEPT:FORMATION))
((FORM CONCEPTS)
(CONCEPT:FORMATION))
((CONCEPT:LEARNING)
(CONCEPT:FORMATION))
((CONCEPT LEARNING)
(CONCEPT:FORMATION)))
IMPLICIT:ARGS NIL
EXPLICIT:ARGS NIL
WHAT (TUPLE LEARN HOW TO IMPOSE A CONCEPT
STRUCTURING UPON A DOMAIN;
LEARN HOW TO CHARACTERIZE, OR
AT LEAST DISTINGUISH, VARIOUS
CONCEPTS)
HOW (TUPLE BY CHOOSING THE DESIRED TYPE
OF CONCEPT FORMATION CALLED
FOR, AND THEN CARRYING IT OUT)
WHY (TUPLE CONCEPT:LEARNING IS NECESSARY
TO CONCEPT KNOWLEDGE)
SPEC:WHY (NO SPECIAL REASON)
WHEN (((IS (ABILITY ?TYPE:OF:C:F))
-70
(TUPLE BECAUSE IF WE CAN ALREADY
DO ?TYPE:OF:C:F THEN WE
SHOULDNT TRY TO DO IT OVER
AGAIN))
((IS (NECESSARY (CHARACTERIZE
CLASSES)))
88
(TUPLE BECAUSE CONCEPT FORMATION
IS A GOOD WAY TO GET A
CHARACTERIZATION OF CLASSES)
)
((ATTEMPT (IS (NEW INFORMATION
←←ANYTHING))
THEN NIL ELSE T)
40
(TUPLE BECAUSE NEW INFORMATION
MIGHT ALTER OUR COURSE OF
ACTION))
((IS (NEW INFORMATION ←←ANYTHING))
-60
(TUPLE BECAUSE NEW INFORMATION
MIGHT ALTER OUR COURSE OF
ACTION)))
META:CODE (EVAL (LIST ?TYPE:OF:C:F))
COMMENTS NIL
PRE:REQUISITES [(AWARE USER
(PUP IS ABOUT TO
WORK ON
CONCEPT
FORMATION))
(TYPE OF
CONCEPT:FORMATION IS
TYPE:OF:C:F)
(AWARE
USER
(THE TYPE OF CONCEPT
FORMATION PUP IS
ABOUT TO WORK ON
IS (@ TYPE:OF:C:F]
CO:REQUISITES NIL
POST:REQUISITES ((AWARE
USER
(PUP HAS THOUGHT ABOUT
THE (@
TYPE:OF:C:F)
TYPE OF
CONCEPT:FORMATION)))
EXPLICIT:ARGS:CHECK T
DEMONS (INFERENCE:DEMONS ATTENTION:DEMONS)
MAIN:EFFECTS (((ABILITY (LEARN CONCEPTS))
(CONCEPT:FORMATION)))
MINOR:EFFECTS NIL
AFFECTS ((EVAL TYPE:OF:C:F)
CALLED)
COMPLEXITY:VECTOR (.1
(PLUS
.2
(TIMES
.8
(DIMENSION2
TYPE:OF:C:F)))
(PLUS
.1
(TIMES
.9
(DIMENSION3
TYPE:OF:C:F)))
.5)
GENERALIZATIONS (ATTEND LEARN
INDUCTIVE:INFERENCE)
SPECIALIZATIONS (THE 9 DECISIONS GO HERE)
ALTERNATIVES ((GRAMMATICAL:INFERENCE
PATTERN:RECOGNITION
SIMULATED:EVOLUTION)))
(PUTPROPS EXTRACT:RELEVANT:SUBSET IDEN [((EXTRACT:RELEVANT:SUBSET
←NEW:INFO)
(LIST
EXTRACT:RELEVANT:SUBSET
(TRANSLATE $NEW:INFO]
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE EXTRACT THE SMALL
NUCLEUS OF RELEVANT
INFO FROM (@ NEW:INFO))
HOW (TUPLE BY DELETING ALL THE
IRRELEVANT INFO FROM
(@ NEW:INFO))
WHY (TUPLE ONLY A SMALL AMOUNT OF
INFO IS RELEVANT TO ANY
SPECIFIC PROBLEM, AND
PUP CANNOT HANDLE A
LARGE MASS OF INFO
EFFICIENTLY)
SPEC:WHY (NO SPECIAL REASON)
WHEN (((GREATERP (SIZE NEW:INFO)
50)
70
(TUPLE BECAUSE IF THE NEW
INFO IS OVER 50
TOKENS LONG, THEN WE
CANNOT EFFICIENTLY
COMPREHEND IT))
((LESSP (SIZE NEW:INFO)
12)
-80
(TUPLE BECAUSE IF THE NEW
INFO IS LESS THAN A
DOZEN TOKENS LONG
THEN WE SHOULD EASILY
BE ABLE TO PROCESS IT
AS IT IS)))
META:CODE [PROGN
(
USE:PROGRAMMING:KNOWLEDGE APPLIED TO NEW:INFO SO:AS:TO KEEP
(TUPLE RELEVANT NEW:INFO))
(ASSERT
(RELEVANT
(@ NEW:INFO]
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK (IS
(NEW
INFORMATION
(@ NEW:INFO)
))
DEMONS NIL
MAIN:EFFECTS (((RELEVANT ←NEW:INFO)
(
EXTRACT:RELEVANT:SUBSET $NEW:INFO)))MINOR:EFFECTS NIL
AFFECTS ((
APPLY:PROGRAMMING:KNOWLEDGE CALLED))COMPLEXITY:VECTOR (.3 .6 .6 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS GET:NAME BEING T
IDEN (((CALL ←←OBJECT ←ITS:NAME)
(TUPLE GET:NAME $OBJECT $ITS:NAME))
(NAME ←OB1 ←OB2)
(TUPLE GET:NAME $OB1 $OB2))
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (EXPRESSION NEW:NAME)
WHAT (TUPLE IDENTIFY THE NEW:NAME (@ NEW:NAME)
WITH THE EXPRESSION (@ EXPRESSION))
HOW (TUPLE PUP WILL ASK THE USER WHAT HE WISHES TO
CALL (@ EXPRESSION))
WHY (TUPLE BOTH PUP AND THE USER MAY NEED TO REFER
TO (@ EXPRESSION))
SPEC:WHY [TUPLE WE CALL THE SIMPLEST BEING WHICH
CAN BRING ABOUT THE EFFECT
(AWARE USER
(PUP WANTS USER TO TYPE IN
NAME FOR (
CONCEPT:FORMATION]
WHEN (((IS (NAME (@ EXPRESSION)
←ANYTHING))
-90
(TUPLE BECAUSE PUP FROWNS ON AMBIGUITY))
((ATTEMPT (IS (NAME (@ EXPREESION)
←ANYTHING))
THEN NIL ELSE T)
50
(TUPLE BECAUSE MOST THINGS SHOULD HAVE
NAMES)))
META:CODE [ASSERT
(NEW:NAME
(@ EXPRESSION)
(@ (COND ((ATOM NEW:NAME)
(SET NEW:NAME (READ)))
(T (SET (EVAL NEW:NAME)
(READ]
COMMENTS NIL
PRE:REQUISITES [(PLAUSIBLE NAMES FOR (@ EXPRESSION)
HAVE BEEN STUDIED)
(AWARE USER (PLAUSIBLE
NAMES FOR (@ EXPRESSION)))
(AWARE USER
(PUP WANTS USER TO TYPE IN
NAME FOR (@ EXPRESSION]
CO:REQUISITES NIL
POST:REQUISITES [(AWARE
USER
(PUP
AND USER ARE NOW ABLE TO
REFER TO (@ EXPRESSION)
AS
(@ (EVAL NEW:NAME))
WHICH IS
(@ (EVAL (EVAL NEW:NAME]
EXPLICIT:ARGS:CHECK T
DEMONS NIL
MAIN:EFFECTS [((ABILITY (REFER PUP ←E AS ←NM))
(GET:NAME $E $NM))
((ABILITY (REFER USER ←E AS ←NM))
(GET:NAME $E $NM))
((NAME ←OB ←NM)
(GET:NAME $OB (TUPLE QUOTE $NM]
MINOR:EFFECTS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.1 .3 .2 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
EFFECTS T)
(PUTPROPS GET:NEW:INFORMATION IDEN (((GET:NEW:INFORMATION ←NEW:INFO)
(TUPLE GET:NEW:INFORMATION
$NEW:INFO)))
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE GET THE NEW PIECE OF
INFORMATION AND CALL IT
NEW:INFO)
HOW (TUPLE ASK THE USER FOR NEW
INFORMATION)
WHY (TUPLE WE NEED NEW INFORMATION; SEE
ESPECIALLY SPEC:WHY)
SPEC:WHY (TUPLE NOW THAT WE HAVE
SELECTED
GET:NEW:INFORMATION AS
THE BEST BEING OUT OF
THE SET
(TRANSLATE
GET:NEW:INFORMATION
ANALYZE:IMPLICATIONS
EXTRACT:RELEVANT:SUBSET)
WE MUST CARRY OUT
(GET:NEW:INFORMATION
U))
WHEN (((ATTEMPT (IS (NEW INFORMATION
←←ANY))
THEN
(FAIL)
ELSE T)
50
(TUPLE BECAUSE AN ABSENCE OF NEW
INFO ABDUCTIVELY IMPLIES
A NEED FOR NEW INFO))
((IS (NEW INFORMATION ←←ANY))
-60
(TUPLE BECAUSE THE PRESENCE OF
UNASSIMILATED NEW INFO IS
AN OMEN THAT WE HAVEN'T
DONE ALL WE MIGHT TO
PROCESS $ANY)))
META:CODE [PROGN
[ASSERT
(NEW
INFORMATION
(@ (SET NEW:INFO
(READ]
(ATTEMPT
[DENY
(IS
(AWARE USER
(PUP WANTS
←←ANYTHING:AT:ALL]
THEN
(ASSERT
(AWARE USER
(PUP WANTED
$$ANYTHING:AT:ALL]
COMMENTS NIL
PRE:REQUISITES ((AWARE USER
(PUP WANTS ←←W)))
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE SPECIFICITY:CHECK:DEMON)
MAIN:EFFECTS (((NEW INFORMATION ←←W)
(GET:NEW:INFORMATION
$$W)))
MINOR:EFFECTS $W
AFFECTS NIL
COMPLEXITY:VECTOR (.1 .1 .1 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS MESSAGE IDEN (((MESSAGE ←M)
(TUPLE MESSAGE $M)))
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (M)
WHAT (TUPLE GIVE THE USER THE MESSAGE (@ M))
HOW (TUPLE THE USER WILL READ THE MESSAGE
(@ M)
THAT PUP TYPES OUT)
WHY (TUPLE SO THAT THE USER MAY ASSIMILATE THE
INFORMATION IN THE MESSAGE (@ M))
WHEN (((AWARE USER $M)
-200))
META:CODE [PROGN (PRIN1 "PUP: ")
(PRINT M)
(TERPRI)
(ASSERT (LASTRESPONDER PUP))
(DENY (LASTRESONDER USER))
(ASSERT (AWARE USER (@ M)))
(ASSERT (READ USER (@ M]
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK T
DEMONS NIL
MAIN:EFFECTS (((AWARE USER ←M)
(MESSAGE $M))
((READ USER ←M)
(MESSAGE $M)))
MINOR:EFFECTS ((LASTRESPONDER PUP))
AFFECTS NIL
COMPLEXITY:VECTOR (0.0 .1 .9 .7)
GENERALIZATIONS (COMMUNICATE I/O)
SPECIALIZATIONS (RESPOND QUERY)
ALTERNATIVES NIL
SPEC:WHY [TUPLE WE CALL THE SIMPLEST BEING WHICH
CAN BRING ABOUT THE EFFECT
(AWARE USER
(PUP WANTS USER TO TYPE IN
NAME FOR (
CONCEPT:FORMATION]
NIL (WE CALL THE SIMPLEST BEING WHICH CAN BRING
ABOUT THE EFFECT
(AWARE USER (PUP WANTS ANY TASK))))
(PUTPROPS OBTAIN:USABLE:INFORMATION IDEN (((OBTAIN:USABLE:INFORMATION
←U)
(TUPLE
OBTAIN:USABLE:INFORMATION $U))
)
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (U)
WHAT (TUPLE OBTAIN SOME
INFORMATION WHICH CAN
BE USED)
HOW (TUPLE OBTAIN NEW FACTS ABOUT
OLD INFORMATION, OR
OBTAIN TOTALLY NEW
INFORMATION)
WHY (TUPLE PUP HAS NO MORE
INFORMATION THAT IT
CAN USE TO PROGRESS)
SPEC:WHY (TUPLE NOW THAT WE HAVE
SELECTED
GET:NEW:INFORMATION AS
THE BEST BEING
OUT OF THE SET
(TRANSLATE
GET:NEW:INFORMATION
ANALYZE:IMPLICATIONS
EXTRACT:RELEVANT:SUBSET)
WE MUST CARRY OUT
(
GET:NEW:INFORMATION U)) WHEN NIL
META:CODE [PROGN
(/SETQ BECAUSE
(TUPLE TUPLE
WE CAN
ONLY TRY
TO
OBTAIN
USABLE
INFORMATION IN
ONE WAY
AT A
TIME))
(CHOOSE:FROM
(CLASS
(TRANSLATE U)
(
GET:NEW:INFORMATION U)
(
ANALYZE:IMPLICATIONS U)
(
EXTRACT:RELEVANT:SUBSET U] COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK T
DEMONS NIL
MAIN:EFFECTS (((USABLE
(NEW INFORMATION
←U))
(
OBTAIN:USABLE:INFORMATION $U))
((NEW INFORMATION
←U)
(
OBTAIN:USABLE:INFORMATION $U))) MINOR:EFFECTS NIL
AFFECTS (TUPLE (CHOOSE:FROM
CALLED)
(TRANSLATE
POSSIBLE:CALLED)
(
GET:NEW:INFORMATION POSSIBLE:CALLED)
(
ANALYZE:IMPLICATIONS POSSIBLE:CALLED)
(
EXTRACT:RELEVANT:SUBSET POSSIBLE:CALLED))
COMPLEXITY:VECTOR (.5 .5 .5 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS PROPOSE:PLAUSIBLE:NAMES BEING T
IDEN (((PROPOSE PLAUSIBLE NAMES FOR
←←SOMETHING)
(PROPOSE:PLAUSIBLE:NAMES
$SOMETHING))
((PROPOSE:PLAUSIBLE:NAMES
←←SOMETHING)
(PROPOSE:PLAUSIBLE:NAMES
$SOMETHING)))
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (EXPRES)
EXPLICIT:ARGS:CHECK [COND
((ATOM EXPRES)
(SETQ
EXPRES
(
COLON:BREAK EXPRES)))
(T
(SETQ
EXPRES
(PROG
(TEMP1)
[FOR
XXX
IN
EXPRES DO
(SETQ
TEMP1
(
APPEND TEMP1 (COLON:BREAK XXX]
(RETURN
TEMP1]
WHAT (TUPLE PROPOSE PLAUSIBLE NAMES
FOR (@ EXPRES))
HOW (TUPLE USE PARLOR PSYCHOLOGY TO
EXTRACT MNEMONIC
CONTRACTIONS OF
(@ EXPRES))
WHY (TUPLE AID THE USER OR PUP IN
CHOOSING A EXPRES FOR
THE OBJECT (@ EXPRES))
SPEC:WHY (TUPLE WE CALL THE
SIMPLEST BEING
WHICH CAN BRING
ABOUT THE EFFECT
(PLAUSIBLE
NAMES FOR
(CONCEPT:FORMATION
)
HAVE BEEN STUDIED)
)
MAIN:EFFECTS (((PLAUSIBLE NAMES FOR
←SOMETHING
HAVE BEEN
STUDIED)
(
PROPOSE:PLAUSIBLE:NAMES $SOMETHING)))
MINOR:EFFECTS NIL
WHEN ((T
(ATTEMPT
(IS (PLAUSIBLE
NAMES FOR
(@ EXPRES)
HAVE BEEN STUDIED))
THEN -99 ELSE 33)
(TUPLE BECAUSE WE SHOULDNT
WASTE TOO MUCH TIME
GETTING PLAUSIBLE
NAMES, YET WE ALSO
SHOULDNT COMPLETELY
LET THE USER FEND
FOR HIMSELF ON THIS
SUBJECT)))
META:CODE (PROG
(P)
(SETQ
P
(MAPCAR
[LIST
(INITIALS EXPRES)
(MAIN:WORDS
EXPRES)
(FIRST:FEW
(INITIALS
EXPRES))
(FIRST:FEW
(MAIN:WORDS
EXPRES))
(FIRST:FEW
(INITIALS
(MAIN:WORDS
EXPRES)))
(LIST
(PACK
(INITIALS
EXPRES)))
(LIST
(PACK
(FIRST:FEW
(INITIALS
EXPRES]
(QUOTE COLON:BACK)))
(SETQ P (SETDIFFERENCE
P KNOWN:NAMES))
(SETQ P (INTERSECTION
P P))
[MATCHQ
←MSG
(ASSERT
((@ P)
IS THE SET OF
PLAUSIBLE NAMES OF
(@ EXPRES]
(ASSERT
(PLAUSIBLE
NAMES FOR
(@ EXPRES)
HAVE BEEN STUDIED))
(RETURN P))
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES ((AWARE USER $MSG))
DEMONS (TUPLE
FRINGE:OF:CONCIOUSNESS:DEMON
PSYCHOLOGY:DEMON)
AFFECTS NIL
COMPLEXITY:VECTOR (.1 .2 .3 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS SATISFY IDEN [((SATISFY ←G)
(LIST SATISFY (TRANSLATE $G]
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (G)
WHAT (TUPLE SATISFY THE SIMPLE SUBGOAL
(@ G))
HOW (TUPLE PASS CONTROL TO THE SIMPLEST SUFFICIENT
BEING)
WHY (TUPLE (@ G)
IS A REQUISITE TO BE SATISFIED)
WHEN NIL
META:CODE [COND
((ATTEMPT (IS (@ G))
THEN T)
T)
(T
(PROG
(B:LIST)
(MATCHQ ←G (@ G))
(FOR
B1 IN (PULLOUT SATISFY
SET:OF:BEINGS)
DO
(FOR
X IN (GETP B1 MAIN:EFFECTS)
UNTIL
(ATTEMPT (MATCH (CAR X)
$G)
THEN
(SETQ
B:LIST
(APPEND
(CDR X)
B:LIST)))
DO NIL))
(/SETQ BECAUSE
(TUPLE TUPLE WE CALL THE
SIMPLEST BEING WHICH
CAN BRING ABOUT THE
EFFECT $G))
(FOR X IN (SORT B:LIST
A:BEING:ORDER)
UNTIL
(ATTEMPT (IS $G)
THEN T)
DO
(ATTEMPT (EVAL X)))
(IS $G)
(ASSERT (TUPLE SATISFIED $G]
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK T
DEMONS NIL
MAIN:EFFECTS (((SATISFIED ←G)
(SATISFY $G)))
MINOR:EFFECTS NIL
AFFECTS [APPEND
[MAPCAR
(PROG
(B:LIST)
(MATCHQ ←G (@ G))
(FOR
B1 IN (PULLOUT SATISFY
SET:OF:BEINGS)
DO
(FOR X IN (GETP B1 MAIN:EFFECTS)
UNTIL
(ATTEMPT
(MATCH (CAR X)
$G)
THEN
(SETQ B:LIST
(APPEND (CDR X)
B:LIST)))
DO NIL))
(RETURN B:LIST))
(FUNCTION
(LAMBDA
(Y)
(COND
(Y (CONS Y (QUOTE (POSSIBLE:CALLED
]
(QUOTE ((TRY:BEING CALLED)
(SORT CALLED)
(A:BEING:ORDER CALLED]
COMPLEXITY:VECTOR (0.0 .3 .2 .4)
GENERALIZATIONS (SERVE)
SPECIALIZATIONS (TRY:BEING)
ALTERNATIVES (WRITE:PROGRAM
ADAPT:PRECONCEIVED:FUNCTION)
BEING T
SPEC:WHY [TUPLE WE CALL THE SIMPLEST BEING WHICH
CAN BRING ABOUT THE EFFECT
(AWARE USER (PLAUSIBLE NAMES FOR
(
CONCEPT:FORMATION] NIL NIL)
(PUTPROPS SERVE IDEN (((SERVE)
(LIST SERVE)))
IMPLICIT:ARGS NIL
EXPLICIT:ARGS NIL
WHAT (TUPLE DO ANYTHING THE USER ASKS)
HOW (TUPLE GET A TASK FROM THE USER)
WHY (TUPLE FUNDAMENTAL DRIVE TO SERVE THE USER)
WHEN NIL
META:CODE (PROGN
(/SETQ UNKNOWN:TASK NON:EXECUTABLE)
(/SETQ BECAUSE
(TUPLE TUPLE THE CURRENT TASK
(@ UNKNOWN:TASK)
IS NOT EXECUTABLE AND WE
HAVE NOTHING ELSE TO DO AT
THE PRESENT TIME))
(UNTIL (ATTEMPT
(IS (EXECUTABLE UNKNOWN:TASK))
THEN T ELSE
(PROGN (ASSERT (APPLYING DEMONS)
APPLY
$USER:INTERRUPT:DEMONS)
NIL))
DO
(OBTAIN:USABLE:INFORMATION
(QUOTE UNKNOWN:TASK)))
(ASSERT (ATTEMPTING (@ UNKNOWN:TASK)))
(/SETQ BECAUSE
(TUPLE TUPLE WE FINALLY HAVE AN
EXECUTABLE TO TASK TO DO,
NAMELY (@ UNKNOWN:TASK)))
(EVAL UNKNOWN:TASK))
COMMENTS ((ASSERT (PUP WANTS ANY TASK)))
PRE:REQUISITES ((AWARE USER (PUP WANTS ANY TASK)))
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK NIL
DEMONS NIL
MAIN:EFFECTS (((ATTEMPTING ←TASK)
(SERVE)))
MINOR:EFFECTS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.2 .4 .6 .8)
GENERALIZATIONS NIL
SPECIALIZATIONS (WRITE:PROGRAM COUNSEL)
ALTERNATIVES (IGNORE REBEL)
BEING T
SPEC:WHY (TUPLE WE CALL THE SIMPLEST BEING WHICH CAN
BRING ABOUT THE EFFECT
(AWARE USER (PUP WANTS ANY TASK)))
NIL NIL)
(PUTPROPS TRANSLATE IDEN (((TRANSLATE ←NEW:INFO)
(TUPLE TRANSLATE $NEW:INFO)))
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (NEW:INFO)
WHAT (TRANSLATE A PIECE OF UNTRANSLATED NEW
INFORMATION)
HOW (TRANSFORM (@ NEW:INFO)
INTO MORE EXECUTABLE FORM)
WHY (NEW INFORMATION (@ NEW:INFO)
IS DECLARATIVE AND MUST BE MADE
PROCEDURAL BEFORE IT MAY BE USED BY THE
SYSTEM)
SPEC:WHY (TUPLE NOW THAT WE HAVE SELECTED
TRANSLATE AS THE BEST BEING OUT
OF THE SET (TRANSLATE
GET:NEW:INFORMATION
ANALYZE:IMPLICATIONS
EXTRACT:RELEVANT:SUBSET)
WE MUST CARRY OUT (TRANSLATE
U))
WHEN (((IS (USABLE INFORMATION ←←ANY))
-60
(TUPLE BECAUSE WE MAY NOT HAVE FULLY
ASSIMILATED THE USABLE INFORMATION
$ANY))
((ATTEMPT (IS (USABLE INFORMATION ←←ANY))
THEN
(FAIL)
ELSE T)
50
(TUPLE BECAUSE THE ABSENCE OF USABLE
INFORMATION ABDUCTIVELY CALLS FOR
THE NEED TO PRODUCE SOME VIA
TRANSLATION)))
META:CODE (QPROG
(←N:INFO ←TRANSLATION)
(ATTEMPT
(IS (TRANSLATION
OF
(@ (EVAL NEW:INFO))
IS ←TRANSLATION))
ELSE
(MATCHQ ←TRANSLATION NON:EXECUTABLE)
)
(MATCHQ ←N:INFO (@ (EVAL NEW:INFO)))
[COND ((ATTEMPT (IS (EXECUTABLE
$TRANSLATION))
THEN NIL ELSE T)
(ATTEMPT (DENY (NEW
INFORMATION
$N:INFO)))
(MATCHQ ←TRANSLATION
(BLIND:BREAK:UP
(TUPLE $$N:INFO)))
(ASSERT (NEW INFORMATION
(TRANSLATION
OF $N:INFO IS
$TRANSLATION]
(COND
(NEW:INFO
(SET NEW:INFO $TRANSLATION)
[COND
((NOT (EQUAL (EVAL NEW:INFO)
NON:EXECUTABLE))
(ASSERT (EXECUTABLE
(@ NEW:INFO]
$TRANSLATION)))
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK [ATTEMPT
[IS
(NEW INFORMATION
(@ (EVAL NEW:INFO]
ELSE
(COND
((NULL
(@ (EVAL NEW:INFO)))
T)
(T (FAIL]
DEMONS (TUPLE IDIOM:DEMON)
MAIN:EFFECTS (((USABLE ←NEW:INFO)
(TRANSLATE $NEW:INFO)))
MINOR:EFFECTS (NEW INFORMATION (@ NEW:INFO))
AFFECTS (TUPLE (LOOKUP CALLED)
(PARSE CALLED))
COMPLEXITY:VECTOR (.3 .5 .5 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL)
(PUTPROPS TRY:BEING IDEN [((TRY:BEING ←B ←ARGS)
(LIST TRY:BEING (TRANSLATE $B)
(TRANSLATE $ARGS]
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (B ARGS)
EXPLICIT:ARGS:CHECK (COND
((AND
(EQUAL T (GETP B BEING))
(EQUAL
(LENGTH (GETP B
EXPLICIT:ARGS))
(LENGTH ARGS)))
T)
(T (FAIL)))
WHAT (TUPLE CARRY OUT BEING (EVAL B)
WITH ARGUMENTS (EVAL ARGS))
META:CODE (PROG (FINAL:CO:REQ FN:VALUE)
(/SETQ BEING:STACK (CONS B
BEING:STACK))
(FOR X IN (GETP B EXPLICIT:ARGS)
AS Y IN ARGS DO
(SET X Y))
(EVAL (GETP B EXPLICIT:ARGS:CHECK)
)
(MAPC (GETP B PRE:REQUISITES)
SATISFY)
(PUSH:DEMONS (GETP B DEMONS))
(MAPC (GETP B CO:REQUISITES)
TRY:TO:SATISFY)
(MAPC (GETP B COMMENTS)
EVAL)
(PUT B SPEC:WHY (QUOTE BECAUSE))
(ASSERT (APPLYING DEMONS)
APPLY
$USER:INTERRUPT:DEMONS)
(SETQ FN:VALUE
(EVAL (GETP B META:CODE)))
(MAPC FINAL:CO:REQ SATISFY)
(POP:DEMONS)
(MAPC (GETP B POST:REQUISITES)
SATISFY)
[FOR X IN (GETP B EXPLICIT:ARGS)
AS Y IN ARGS DO
(COND ((ATOM Y)
(SET Y X]
(/SETQ BEING:STACK (CDR
BEING:STACK))
(RETURN FN:VALUE))
BEING T
SPEC:WHY (NO SPECIAL REASON))
(PUTPROPS WRITE:PROGRAM IDEN [[(WRITE A PROGRAM WHICH DOES ←←TASK)
(WRITE:PROGRAM
(COND
([EQUAL
1
(LENGTH
(PROGN
(SETQ QQ1 $$TASK)
(SETQ QQ2 (QUOTE QQ1))
(ASSERT
(NEW INFORMATION
(@ QQ1)))
(SETQ WP (TRANSLATE QQ2]
(APPEND (QUOTE (TUPLE TUPLE))
WP))
(T (FAIL]
((WRITE:PROGRAM ←TASK)
(TUPLE WRITE:PROGRAM (TRANSLATE $TASK]
BEING T
IMPLICIT:ARGS (TASK:TYPE TASK:NAME)
EXPLICIT:ARGS (TASK)
WHAT (TUPLE WRITE A PROGRAM WHICH DOES
(@ TASK))
HOW (TUPLE CREATE SPECIALIZED LISP CODE WHICH
WILL DO (@ TASK))
WHY (TUPLE FUNDAMENTAL DRIVE TO OBEY USER;
ALSO, IT IS NECESSARY THAT CODE BE
WRITTEN TO DO (@ TASK)
IN ORDER THAT THE TASK
(@ TASK)
MIGHT BE COMPLETED; ALSO, EXAMINE
SPEC:WHY)
SPEC:WHY (NO SPECIAL REASON)
WHEN (((IS (ABILITY (@ TASK)))
-75
(TUPLE BECAUSE A PRE:EXISTING ABILITY
TO DO (@ TASK)
IMPLIES THAT WRITING A NEW
PROGRAM TO ACCOMPLISH IT IS
SUPERFLUOUS))
((IS (PROGRAM (@ TASK)))
-80
(TUPLE BECAUSE WE ARE NOT AFTER MUCH
EFFICIENCY, AND IF A PROGRAM
ALREADY EXISTS, THEN WE SHOULD
USE IT))
((ATTEMPT (IS (ABILITY (@ TASK)))
THEN NIL ELSE T)
40
(BECAUSE THE INABILITY TO DO
(@ TASK)
IS A MILD SIGN THAT WE ARE ON
THE RIGHT TRACK))
([IS (AWARE USER
(PUP IS ABOUT TO WRITE A
PROGRAM TO DO
(@ TASK]
70
(TUPLE BECAUSE WE GO BY THE OLD
ENGLISH LEGAL RULE, THAT
SILENCE SIGNIFIES APPROVAL))
((IS (NEW INFORMATION ←←ANY))
-120
(TUPLE BECAUSE WE SHOULD USE UP THE
NEW INFORMATION BEFORE WRITING
PROGRAMS))
((ATTEMPT (IS (NEW INFORMATION ←←ANY))
THEN NIL ELSE T)
40
(TUPLE BECAUSE IF NO NEW INFO IS
PRESENT, THEN WE NEEDN'T FEEL
GUILTY ABOUT STARTING TO WRITE
A PROGRAM)))
META:CODE [PROG
(DONE I)
(SETQ I (QUOTE I))
[ATTEMPT
(IS (DIFFICULT (@ TASK:TYPE)))
THEN
[SETQ
DONE
(TUPLE OR
(TUPLE COMPLETE
(@ TASK:NAME))
(TUPLE TOO:HARD
(@ TASK]
ELSE
(SETQ DONE (TUPLE COMPLETE
(@ TASK:NAME]
(UNTIL
(EVAL DONE)
DO
(CHOOSE:FROM
(CLASS (
OBTAIN:USABLE:INFORMATION I)
(USE:INFORMATION
I)
(
FILL:IN:UNDEFINED:SECTION I)
(
CLARIFY:IMPROBABLE:SITUATION I)
(
ADAPT:PRECONCEIVED:FUNCTION I)
(FIX:INCORRECT:PIECE
I]
COMMENTS NIL
PRE:REQUISITES ((AWARE USER
(PUP IS ABOUT TO WRITE
A PROGRAM TO DO
(@ TASK)))
(NAME (@ TASK)
TASK:NAME)
(AWARE USER
(THE NAME OF THE
PROGRAM TO DO
(@ TASK)
IS
(@ TASK:NAME)))
(TYPE (@ TASK)
TASK:TYPE)
(AWARE USER
((@ TASK:TYPE)
IS THE TYPE OF
(@ TASK)
TASK THAT PUP IS
WRITING THE PROGRAM
CALLED (@ TASK:NAME)
TO DO)))
CO:REQUISITES NIL
POST:REQUISITES ((AWARE USER
(THE PROGRAM
(@ TASK:NAME)
TO DO
(@ TASK:TYPE)
TYPE OF
(@ TASK)
IS COMPLETE)))
EXPLICIT:ARGS:CHECK T
DEMONS (PROGRAM:WRITING:DEMONS)
MAIN:EFFECTS (((ABILITY ←TASK)
(WRITE:PROGRAM $TASK))
((PROGRAM ←TASK)
(WRITE:PROGRAM $TASK)))
MINOR:EFFECTS NIL
AFFECTS ((OBTAIN:USABLE:INFORMATION
POSSIBLE:CALLED)
(USE:INFORMATION POSSIBLE:CALLED)
(FILL:IN:UNDEFINED:SECTION
POSSIBLE:CALLED)
(CLARIFY:IMPROBABLE:SITUATION
POSSIBLE:CALLED)
(ADAPT:PRECONCEIVED:FUNCTION
POSSIBLE:CALLED))
COMPLEXITY:VECTOR ((PLUS .3
(TIMES .6
(DIMENSION1
TASK:TYPE)))
.9 .7 .5)
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
ISEN T)
(MAPC SET:OF:BEINGS SEMI:COMPILE)
STOP